500 MB Nyheder Direkte fra Internet 2/500 MB nyheder direkte fra internet CD 2.iso/start/data/text/faq-1039.txt

Text File | 1995-05-05 | 61KB | 1,569 lines

Archive-name: object-faq/part5
Last-Modified: 10/27/94
Version: 1.0.7

o  Visual Program Designer -- The Visual Program Designer allows developers
   to visually create and modify the behavior of an application without
   having to write code. Programs are created by connecting visual program
   blocks to field blocks drawn from the forms created in the Forms
   Designer. A large collection of predefined program blocks is provided
   with GeODE, and users can extend the catalog in any of a number of
   simple ways. Code-based programming can be integrated routinely.

o  Developer Class Library - GeODE comes standard with more than 480
   classes and thousands of methods, and is easily extended for handling
   specialized applications. In a team environment, some programmers can
   develop visual applications while others write new methods that are
   encapsulated into visual program blocks for easy reuse.

o  Developer Tools -- GeODE includes tools for debugging, browsing and
   inspecting applications. Included in this set of tools are several
   debuggers, browsers, inspectors, an object clipboard, an image editor,
   and a code profiler for performance analysis.


 ==============================================================================

PLATFORMS

GemStone release 3.2 and GeODE 2.0 and all language interfaces are
available for UNIX workstations and servers from SUN, HP, IBM, Sequent, and
DEC. Client-only support is available in a number of languages for Windows
3.1, OS/2 and Macintosh. Servio is an active member in the Object
Management Group and the ANSI Smalltalk standardization committee. Servio
supports SUN ODMG, ANSI C++ and intends to comply fully with the emerging
standards.

 ==============================================================================

REFERENCES

  [Maier, et al. 84] D. Maier, J. Stein, A. Otis, A. Purdy, ``Development
  of an object-oriented DBMS'' Report CS/E-86-005, Oregon Graduate Center,
  April 86 - ACM 0-89791-204-7/86/0900-0472

  R.G.G. Cattell: Object Data Management - Object-Oriented and Extended
  Relational Database Systems; Addison-Wesley. ISBN 0-201-53092-9

  Robert Bretl, David Maier, Allen Otis, Jason Penney, Bruce Schuchardt,
  Jacob Stein, E. Harold Williams, Monty Williams. "The GemStone Data
  Management System." Chapter 12 of "Object-Oriented Concepts, Databases
  and Applications", by Kim and Lochovsky.


 ==============================================================================

CONTACTS

 === Headquarters - San Jose ====

Servio Corporation
2085 Hamilton Avenue
Suite 200
San Jose  CA  95125

Tel: [phone]
Tel: [phone]
Fax: [phone]

 === Chicago ====

Servio Corporation
8410 Bryn Mawr
Suite 400
Chicago  IL  60631

Tel: [phone]
Fax: [phone]

 ===  New York ====

Servio Corporation
1120 Avenue of the Americas
4th Floor
New York  NY  10036

Tel: [phone]
Fax: [phone]

 === Dallas ====

Servio Corporation
14875 Preston Road
Suite 550
Dallas  TX  75240

Tel: [phone]
Fax: [phone]

 === Europe/UK ====

Servio UK
Criterion House
Beauchamp Court, Victors Way
Barnet  EN5 5TZ  England

Tel: [phone]
Fax: [phone]

 === Japan ====

Servio Corporation
Daito-Eiwa Building, 7F
5-11 Nihonbashi-Hakozakicho
Chuo-ku  Tokyo 103  Japan

Tel: [phone]
Fax: [phone]

 =====================
 === Distributors ====
 =====================

 === Germany, Austria, Switzerland ====

ObjectOriented System Technologies
Baroper Str. 337
Dortmund  50  W-4600
Germany

Tel: [phone]
Fax: [phone]

 === Japan ====

Japan Information Processing Service Co., Ltd.
2-4-2 Toyo , Koto-ku
Tokyo, 135, JAPAN

Tel: [phone]
Fax: [phone]

--------------------

Nexus Technology K.K.
Suite 901
Botan 3-11-1
Koto-ku  Tokyo 135  Japan

Tel: [phone]
Fax: [phone]

 === Taiwan ====

Anco Technologies
11-1F, 76 Tun Hwa S. Road, Sec. 2
Taipei
Taiwan, R.O.C.

 === Italy ====

Etnoteam S.P.A.
Via Adelaide Bono Cairoli 34
Milano  20127  Italy

Tel: [phone]
Fax: [phone]

 === England ====

AI International Ltd.
1 Parkview Road
Berkhamsted
Herts  HP4 2EY  England

Tel: [phone]
Fax: [phone]

 ==== Mexico ====

TEIX, Sistemas de Informacion
Estrategica S.A. de C.V.
Antonio M. Anza No. 43
Col Roma  Mexico D.F.  06700

Tel: [phone]


> ITASCA
                       ITASCA ODBMS V2.2

                      Itasca Systems, Inc.
                       7850 Metro Parkway
                      Minneapolis, MN 55425
                        [e-mail]
                         [phone]

                          Sandy Miezwa
                         [phone]

Introduction

Itasca Systems develops, markets, and supports ITASCA, a distributed
active object database management system and related tools. The initial
research work for ITASCA occurred in the Object-Oriented and Distributed
Systems Lab at the Microelectronics and Computer Technology
Corporation (MCC) in Austin, Texas. The research was known as the
ORION prototypes.

The ITASCA Distributed ODBMS is a language neutral, full-featured, active
object database that supports data access from various object
languages. ITASCA allows clients to transparently access data that is
distributed among multiple servers.  ITASCA supports full dynamic schema
modification that can be performed during any phase of the software
lifecycle.  Applications written in dissimilar and incompatible languages,
such as C++ and CLOS, share objects through ITASCA. ITASCA stores methods
inside the database, promoting reusability and maintainability.  The only
commercial ODBMS based upon the MCC Orion technology, ITASCA is considered
by many to be the most feature-rich ODBMS on the market today.

This overview describes release 2.2 of the ITASCA Distributed Object
Database Management System. It describes how ITASCA functions,
outlines its implementation features, and explains some of the system
benefits.


History of ITASCA

ITASCA is based on a series of object database research prototypes. Work
on these prototypes began in 1985 at the Microelectronics and Computer
Technology Corporation (MCC) Object-Oriented and Distributed Systems
Laboratory. MCC released the first prototype, ORION-1, in May, 1987, as
a single-user system. MCC extended ORION-1 to the ORION-1SX
prototype system and released it to the shareholder companies in April,
1988. ORION-1SX was a multi-user system with a multi-client, single
server architecture. The third prototype, ORION-2, introduced a distributed,
object-oriented architecture for a multi-user environment. MCC released
the third prototype to shareholder companies in July, 1989. ORION-2 has a
multi-client, multi-server architecture. Having met its objectives, MCC
stopped all work on ORION at that time. Over five million dollars was spent
for the three generations of prototypes.

The ITASCA product is an extension and commercialization of the ORION-2
prototype from MCC. Itasca Systems has added major enhancements and
features, improved the performance, and strengthened the code. It now runs
on UNIX systems from multiple vendors. ITASCA is an industrial-strength,
documented product, fully supported by Itasca Systems, Inc. Itasca Systems
continues to develop tools and other products to work with ITASCA.


Overview

ITASCA employs a distributed architecture with private and shared objects
spread across UNIX-based computers on a local-area network. The
ITASCA model follows the object-oriented view that uniformly models any
real-world entity as an object. Each object has a unique identifier along with
a state and behavior. Attributes represent the state of an object. Methods
(code) define the behavior of an object. A class object collects objects that
share the same set of attributes and methods. Subclasses derive from
existing classes. The resulting schema, or database definition, is a class
hierarchy. Each subclass inherits all the attributes and methods of its
superclasses. ITASCA supports multiple inheritance. A subclass may derive
from more than one superclass.

One of the breakthroughs of object-oriented technology is the reusability of
code. ITASCA allows for the active management of both reusable code and
data in an integrated system. Developers may write applications in C++,
CLOS, C or Common Lisp. This means ITASCA is language neutral. Objects
stored using one programming language can be accessed by other
programming languages. It also means an application program need not be
written in an object-oriented language.

The ITASCA database management system has features belonging to most any
database system. This includes persistent storage for data and schema,
concurrency control and locking, transaction management, multiple
security levels, and logging and recovery for both CPU and disk media
failure. Additional features of ITASCA include dynamic schema
modification, long-duration transactions, shared and private databases,
distributed version control, distributed transaction management, distributed
query management, distributed change notification, object migration, and
an extensible architecture.

Shared and private databases exist in a distributed environment in ITASCA.
The shared database is distributed across workstations (sites) in a network.
An ITASCA server controls the partition of the shared database at each site.
ITASCA clients provide transparent access to the various partitions of the
shared database. The architecture allows any number of private databases at
each distributed database site. Data can move between private and shared
databases. Private databases allow private data that is not shared with other
users of the database.

ITASCA stores the schema redundantly at each site to improve
performance. The schema storage also includes code in the form of
methods. Management of schema updates is automatic for all sites. This
includes sites that were off-line during any changes. Automatic distribution
of schema changes, including method code changes, simplifies database
administration.

ITASCA stores each instance of data in one site. The system or a user may
move the data from one site to another to improve data locality. Access to
moved data remains transparent. There is no need for a user or application
to know the specificlocation of data in the ITASCA distributed database.
ITASCA will automatically find the location of the data. This simplifies
distributed application development. The developer can rely on ITASCA
finding data in the distributed database.

No single site acts as a master site, thus ITASCA's architecture has no
single point of failure. ITASCA has neither a central data server nor a
central name server. This is important for maintaining a database system
with high availability in a networked workstation environment.

ITASCA supports dynamic schema modification to create a flexible
environment for changing or customizing a database system. Authorized
users can add and remove attributes or change the subclass/superclass
relationship at any time. Authorized users can also add or remove partitions
of the shared database at any time. All this can be done interactively without
affecting other parts of the ITASCA database at the time changes occur to
the schema. There is no need to "bring the system down" or off-load/reload
data to restructure the database. Dynamic schema modification can
significantly reduce maintenance costs. It also is useful in environments
where change to data definitions are normal or relatively frequent.

ITASCA has a sophisticated security authorization technique tied to the
class hierarchy. It supports both positive and negative authorizations at any
level in the class hierarchy. For example, granting access to all objects but
one requires only two authorizations: a global grant followed by a specific
denial. Authorization extends to classes, instances of classes, attributes,
and methods. Also, inheritance of authorization reduces the work of database
administration.

Long-duration transactions allow users to check objects out of the shared,
distributed database into their private databases. Users can then change the
objects in the private databases without affecting the shared database or
other users. These changes can be committed to the private database. Then,
at any later time, the user can check the updated object or objects back into
the shared database.

ITASCA supports version control of objects. A new version of an object
promotes the original or parent object to restrict further changes to the
parent. ITASCA also supports alternate versions such that multiple versions
can have the same parent. Promoting an object version to a released status
restricts any deletion of the object. ITASCA uses generic versions to
dynamically reference the most recent or default version of an object
without any intervention by a user or application.

Change notification in ITASCA is either flag-based or message-based.
Flag-based notification will identify an updated object upon querying the
object for such information. It is a passive notification scheme. Message-
based notification, on the other hand, is an active notification scheme. It
will execute a method (or code) upon an update or other change to an object.
Such methods can send mail messages or invoke other methods or
programs.

Memory management in ITASCA uses both page and object buffers.
ITASCA has a traditional database page buffer scheme that contains pages
with multiple objects. Desired objects move from the page buffer to an
object buffer. The object buffer then provides ITASCA with enhanced in-
memory performance because it contains only frequently-referenced
objects.


> Matisse

OODBMS FEATURES LIST:

An Industrial Strength Open Semantic Object Database

Performance
-       Symmetric, Fine Grain, Multi-Threaded Architecture
-       Parallel and Asynchronous Disk I/O
-       Automatic Disk Optimization through Dynamic Clustering
-       High Speed OLTP Environment
Reliability
-       24 Hour - Mission Critical Operation
-       Media Fault Tolerant (Object Replication)
-       Transparent On-line Recovery
Database Administration
-       Full On-line Administration (No Down Time)
-       On-line Incremental or Full Back-Up
-       Dynamically Increase Database Size -   On-line
-       Full On-line Monitoring
Data Management and Consistency
-       Dynamic Schema Evolution
-       Consistent Database Reads without Locking
-       Historical Versioning, both Schema and Data Objects
-       Built-in Enforced Referential Integrity
-       Object Level Implicit or Explicit Locking
Scalability
-       Hundreds of Concurrent On-line Users
-       Hundreds of Gigabytes Per Database
-       From Few Bytes to Four Gigabytes for Each Object
-       Up to Four Giga-objects Per Database
Object Model
-       Full Object Oriented Model
-       User Extensible Object Meta-Schema
-       Support for Complex, Highly Dynamic, Variable Sized Objects
-       Multiple Inheritance
Intelligent Objects
-       Triggers at Object, Attribute, or at Relationship Level
-       Consistency Rules at Object, Attribute, or at Relationship Level
-       Customizable Intelligent Object Indexing
-       Automatic Inverse Relationships
Open Systems
-       Open C, C++ API
-       Supports Any Commercial Development Tool and Language
-       No Proprietary Tool Required
-       Heterogeneous Cross Platform Client/Server Architecture

For Information on MATISSE, Contact one of the following offices:

USA:
ODB, an Intellitic International Company
238 Broadway
Cambridge, MA  02139
Phone:[phone]
Fax: [phone]
email:  [e-mail]

EUROPE:
INTELLITIC INTERNATIONAL
12-14 rue du Fort de Saint-Cyr
Montigny-le-Bretonneux
78182 Saint Quentin en Yvelines Cedex France
Phone:   [phone]
Fax:    [phone]

JAPAN:
SGN CO. LTD.
Urban Toranomon Building
16-4 Toranomon
Minato-Ku Tokyo 105 Japan
Phone:   [phone]
Fax:   [phone]


> NeoAccess

A cross-platform object-oriented database engine based on C++. It allows
developers to embed the power of a fully-functional object-oriented database
system into their applications. All of the data contained in the database,
including indices, can be in a single file, so users can treat a database
file as they would a standard document file. The programming model is
designed to keep visible complexity to a minimum while providing a
feature-rich foundation on which to build and enhance applications.

NeoAccess has taken a different approach toward the issues surrounding object
persistence than have other solutions that have been offered. We believe that
objects should be viewed as having a set of properties with a pliable state.
With NeoAccess persistent objects are provided with persistence and sharing
properties. These properties allow objects to maintain an association with a
file. This association, which can be built and broken freely, allowing
objects to migrate freely between disk and memory. The API to these
properties address issues such as adding or deleting the object from a file,
sorting and indexing, locating and later freeing the object in memory, object
sharing, and maintaining relationships between objects.

NeoAcces
s with has been fully integrated into standard application frameworks such as
Borland's ObjectWindows and MacApp 3.0 and the THINK Class Library on the
Macintosh. A single source tree can be used to build the engine in all
development environments. Database files are binary-compatible across
platforms so users on different types of machines can share data without
conversion.

Contact:
Bob Krause
NeoLogic Systems
1373 Third Avenue
San Francisco, CA 94122
[phone]


> O2 (INRIA/O2 Technology)

This is an entry on schema evolution.  General papers on O2 are included.

We have implemented in O2 schema updates in our first release but
without NO IMPACT on the database (we have a design to implement
deferred update, but it is a paper design). However, users manage to
convert their instances by hand, using their O2 programs written
themselves, and with the aid of the following tools:

1- There is a set of predefined classes whose instances contain
   objects representing a schema (i.e., a Meta-schema). These classes
   may be used in a conversion program, they may even be extended by
   the programmer.

2- There is a save-restore program that allows to take an O2 database,
   save it on a file or a tape in a logical way (i.e., independent of
   the physical format of objects on disk), and restore it again on a
   (perhaps new release) of the system, in an empty database.
   Currently, when saving a database its schema is also saved. The
   next extension to this save/restore program will be to save the
   database without saving its schema, and then restore the database
   on a new version of that schema. The restore program will be able
   to perform automatically some conversions like "add attribute" or
   "delete attribute".


Schema updates with impact on the database will be implemented in future
releases.

[Fernando Velez <[e-mail]>]


For more information on O2, consult the following REFERENCES:

        Francois Bancilhon, Claude Delobel, Paris
        Kanellakis.  "Building an Object-Oriented Database
        System: The Story of O2".  Morgan Kaufmann Series
        in Data Management Systems, San Mateo, Calif., 1992.

        F. Bancilhon, G. Barbette, V. Benzaken, C. Delobel,
        S. Gamerman, C. Lecluse, P. Pfeffer, P. Richard,
        and F. Velez.  "The Design and Implementation of
        O2, and Object-Oriented Database System".
        Advances in Object-Oriented Database Systems,
        Springer Verlag. (Lecture Notes in Computer Science
        series, Number 334.)

        C. Lecluse, P. Richard, and F. Velez. "O2, an
        Object-Oriented Data Model".  Proceedings of
        SIGMOD88.  Also appears in Zdonik and Maier,
        "Readings in Object-Oriented Database Systems",
        Morgan Kaufmann, 1990.

 ==== Corporate headquarters:
O2 Technology
7 Rue du Parc de clagny
78035 Versailles Cedex
France
tel : [phone]
fax : [phone]

[They have many other contacts worldwide]


> Objectivity/DB (Objectivity)

Introduction:

Objectivity/DB has a fully distributed client/server architecture that
transparently manages objects distributed across heterogeneous environments and
multiple databases.  It provides an application interface that uses transparent
indirection to ensure integrity and provides a single logical view of all
information, with all operations working transparently on any database on the
network, with scalable performance as users and objects increase.  A
higher-level Object Definition Language (ODL) is available as well as a C
functional interface, integrated C++ interface, and SQL++.


Objectivity/DB

Objectivity/DB [Reference:  Technical Overview, Objectivity, 1993], a product
of Objectivity, Inc. of Menlo Park, CA, provides an integrated C++ programming
interface with an emphasis on the DBMS engine for robustness and scalability
from workgroups to enterprise-wide production applications.  In production use
today with more than 50,000 end users licensed, it supports a fully
distributed, rather than central-server, architecture, with all operations
working transparently over a mixture of multiple databases, schemas, users, and
computers, and over heterogeneous hardware, operating systems, and networks.
The language interface includes a C++ class library interface, soon to be ODMG;
a C function library; and SQL++, supporting query predicates with either SQL or
C++ syntax, interactively or programmatically.  Over forty administrative and
GUI tools provide both an interactive and programmatic interface, and a
messaging backplane allows third party tools integration at four different
levels, with a list of partners at all levels.

One of the key architectural concepts of Objectivity/DB is an object reference
mechanism that ensures data integrity.  Unlike traditional ODBMSs that use
direct pointers, which become invalid after commit and hence lead to crashes
and corrupt databases, Objectivity/DB uses an indirection to guarantee safe
reference.  Transparent to the user, this indirection requires an extra test
and pointer dereference, or a couple of cycles, which is not measurable in most
applications.  However, it ensures integrity of all references, even across
transaction boundaries, resulting in production quality robustness.  Also, it
provides object level granularity for the object manager, allowing it to move,
cluster, and swap objects as necessary, one of the keys required for
scalability in objects and users.  Finally, it allows object-level granularity
for current features, such as heterogeneity and versioning, and future
extensions, such as object-level security.

A higher-level Object Definition Language (ODL) is provided that allows
declaration of modeling concepts such as bi-directional associations, behavior
of associations between objects as they version (move, copy drop), and
propagation of methods across associations.  These then result in automatically
generated methods and declarations for both C++ and C.  The standard C++ API
allows application programmers to work with any standard compilers and
debuggers, with no extra pre-processors, providing ODBMS capabilities via
overloading C++ operators (new, ->, etc.), and declarations via provided
classes (for references, etc.).

Workgroup through enterprise-wide and cross-enterprise computing is supported
via a distributed client/server architecture that provides a single logical
view over multiple databases on heterogeneous machines.  The user sees a
logical view of objects connected to objects and need not worry that one object
is in a database on a Sun workstation, while another may be in a database under
Windows or VMS.  All operations work transparently across this environment,
including atomic transactions with two-phase commit, propagating methods, and
versioning.  Objects may be moved between databases and platforms without
affecting working applications or requiring changes to the applications.
Multiple schemas may be created, without affecting other users or databases,
and may be used simultaneously with shared schemas, allowing local groups to
define their own models but still connect to other groups.  Databases may be
detached from this shared environment (federated database) and used on portable
devices, reconnected or moved to different (compatible) environment, or
distributed as parts or image libraries.  Gateways to RDBMSs are provided via
third-party integration with Persistence Software, and more generally to any
foreign data store, as long as the user installs the appropriate access
methods, extending the single-logical-view to include read/write access to
arbitrary foreign data stores.  Together, these allow delegation of
responsibilities to the appropriate users, integration with existing systems,
and gradual migration toward full enterprise-wide sharing.

The on-demand object manager directly and automatically manages object access
and buffering, rather than relying on system facilities such as virtual memory
or user manual get/put calls.  Mechanisms used include multiple buffer pools
locally and remotely, b-trees, hashing, scoped names, keys, and iterators, with
distributed catalogues for schemas and databases.  A direct connection is
established between the user and the objects used, so that users do not
conflict unless and until they are competing for the same objects, thus
avoiding the traditional central-server bottleneck.  Short transactions are
based on traditional (transient) locks, owned by the process, and group
together an arbitrary set of operations.  Long transactions are based on
persistent locks, owned by the user, and provide the same arbitrary grouping.
Default concurrency is two-phase locking and serialization, but extensions
available include MROW, or multiple-readers concurrent with one-writer, and
allow users to lock with or without wait or with timed waits, to implement more
sophisticated mechanisms.

Objects may be modeled using C++ structures augmented by classes provided such
as strings, dictionaries, and relationship management, as well as some
particular domain libraries.  A simple object is a C++ class (or C structure)
with associated access methods.  A complex object may include multiple varrays,
each being a dynamically varying sized array of arbitrary structure.  A
composite object is any network of related objects that acts as a single
object, both structurally and behaviorally, via propagation of behaviors to
component objects.  Any number of composite objects may be contained in
composite objects, and a single object may participate in any number of
composites.  The relationship mechanism supports uni- and bi-directional
relationships, one-to-one, one-to-many, and many-to-many.  Versioning is
supported at object granularity, may be turned on or off at any time for each
object, may be restricted to linear or allow branching with multiple writers.
References to versioned objects may be to a specific version or to the default
version, which may be separately specified by a method and may allow multiple
defaults.  Schema and object evolution are supported via versioning of the
type-defining objects.  Each time a type definition is changed, its defining
object is versioned, allowing arbitrary changes.  Objects may then be instances
of the old or new type version.  Object evolution or upgrading to the new type
version is supported  by the user writing conversion methods which are
installed and invoked by the system.

ANSI SQL query is supported in the SQL++ product.  Predicate syntax may be
either C++ or SQL.  The ODBC and SQL Access Group (SAG) protocols are
supported.  Queries may be invoked programatically or interactively, with ad
hoc support.  Access to object features is available via methods and traversal
of relationships.

Over forty administrative and developer tools are provided, each with both an
interactive and programmatic interface.  These include GUI object and type
browsers, query browsers, report generator, tools to examine and force short
and long locks, to move objects and databases, etc.  On-line incremental backup
provides a consistent network-wide snapshot, including referential integrity
across all databases, and runs incremental and full database backups with no
need to acquiesce the databases and no interference with active applications.
All tools are built around a messaging backplane, which supports four levels of
integration with user and third-party tools.  Integrated products include HP
SoftBench (full operational level), CenterLine's ObjectCenter (tool level),
Persistence RDBMS gateway, PTech and ProtoSoft Design and Analysis (language
level), and XVT and UIM/X (compatibility level).

Objectivity/DB is resold by Digital Equipment Corporation as DEC Object/DB,
providing a multi-billion-dollar second source vendor.  Over 50,000 end users
are licensed in production use, with applications including real-time
telecommunications, aerospace, defense, case, CAD/CAM, CIM, manufacturing, oil
& gas, process control, transportation, multi-media, case, document management,
financial analysis, and corporate information management.  Platform support
includes all Sun, all DEC (including VMS, alpha, OSF-1), HP/9000 series (both
68xxx and PA-RISC), IBM RS/6000, NCR 3300, SGI, Windows 3.1, and Windows NT.

On Schema Evolution (from original survey):
In the just-released Version 2.0 (shipping Oct 92), schema evolution
is supported via dynamic versioning of type-defining objects [ie.
class versions -- SMC], and via a step-by-step approach that allows
conversion of instance data via user-provided conversion methods.
Also, a full dynamic type manager interface is available for doing
fancier things.

Contact:

Drew Wade
Objectivity, Inc.
800 El Camino Real
Menlo Park, CA  94025 USA
[e-mail]
1(415)688-8000 voice
1(415)325-0939 fax
admin ass't:  Vickie Clements ([e-mail])
information:  [e-mail]


> ObjectStore Object Database System From Object Design, Inc.


Product Description

ObjectStore[TM] is a high performance ODBMS designed for ease of use in
development of sophisticated applications using object-oriented
development techniques.  It offers a tightly-integrated language
interface to a complete set of traditional DBMS features including
persistence, transaction management (concurrency control and
recovery), distributed access, associative queries over large amounts
of data, and database administration utilities.  ObjectStore's data
management facilities combined with popular development tools create a
high productivity development environment for implementing
object-oriented applications.

Key Features:

   - Transparent interface designed for popular C and C++ programming
     environments.

   - Concurrent access to large amounts of persistent data.

   - Distribution of objects over networks using a variety of popular
     network protocols.

   - Access to persistent data at the same speed as transient data.

   - Extensible data modeling capabilities for applications requiring
     complex data structures.

   - Easy migration path for existing C and C++ applications.

   - Class libraries for version and configuration management.

   - Class libraries for managing collections of objects.

   - A fully distributed (multi-server/multi-database) ad hoc query
     capability.

   - An interactive Browser to inspect objects and object
     descriptions.

   - Interoperable with ObjectStore servers running on other operating
     systems and hardware environments.

   - Complete schema evolution for an application's metadata and
     existing object instances.

   - Full online backup for continuous processing environments.

   - Meta object protocol with programmatic access to schema
     information.

   - Dynamic Type creation for extending existing class definitions
     during program execution.


System View

ObjectStore supports cooperative access through its flexible
client/server software architecture, which allows users to make the
take advantage of the computational power that exists on the desktop.
ObjectStore's client/server implementation allows one server to
support many client workstations, each workstation to simultaneously
access multiple databases on many servers, and a server to be resident
on the same machine as a client.  ObjectStore's distributed
architecture supports several network environments for
interoperability among popular workstations and PC's and includes
support for TCP/IP, Novell IPX/SPX, other popular network protocols.


Application Interface

Access to ObjectStore is provided through a library based application
interface compatible with popular C and C++ compilers and programming
environments.  The ObjectStore application interface provides support
for C++ compilers -- such as those from workstation suppliers -- and
development environments from independent software vendors such as
Visual C++ from Microsoft, ObjectCenter from CenterLine Software, Inc.
and Energize from Lucid, Inc.  The application interface provides
powerful high-level function calls which enable the programmer to
create multi-user application which share large amounts of data.
These functions include:

   - Relationship Management
   - Version Management
   - Collection Management
   - Storage Management
   - Associative Queries
   - Object Iteration
   - Transaction Management
   - Index Management
   - Clustering

Applications developed using ObjectStore library calls are
source-level compatible with ObjectStore applications developed for
other operating systems on other hardware platforms.

Platforms

ObjectStore is available on the following major platforms:

Unix Workstation Platforms

   - DEC MIPS Ultrix
   - HP 700 Series HP-UX
   - HP 800 Series HP-UX
   - IBM RS/6000 AIX
   - NCR 3000
   - Olivetti LSX-50xx SVR4
   - Silicon Graphics IRIX 5.x
   - SunSoft Intel Solaris 2
   - SunSoft SPARC Solaris 1 SunOS 4
   - SunSoft SPARC Solaris 2 SunOS 5
   - Univel UnixWare

PC Platforms

   - Windows 3.1 (Win32s)
   - Windows NT (Intel)
   - OS/2 Release 2.0 and 2.1
   - Novell Netware Release 3.1 and 4.0 (server only)

The Company

ObjectStore[TM], Object Design's object-oriented database management
system, is currently used by more than 500 companies.  The company
targets end-user customers in major corporations and governments
through its direct sales force, and also focuses on independent
software developers, systems integrators and international
distributors to license its products.  In the systems software market,
Object Design has already licensed object storage technology to
SunSoft that will be embedded in the Solaris(r) (Project DOE)
environment.  Through this relationship Hewlett Packard also has rights
to the technology for use in HP/UX(r) (DOMF).

In April 1993, IBM Corporation became one of the company's leading
investors as part of a far-reaching strategic relationship involving
an equity investment, internal use and joint development agreements.

Object Design's Support Services group provides extensive support
services tailored to meet each customer's specific needs.  A regularly
scheduled series of training courses are offered, either at Object
Design facilities across North America, select international locations
or at customer sites, that reduce the learning curve for
object-oriented development.  The training courses include
"Introduction to Object-Oriented Programming and C++," "Designing
Object-Oriented Database Applications" and "Building High Performance
Applications with ObjectStore."  To further assist its customers,
Object Design makes its team of experts available to provide a wide
range of training, support and consulting services.

The company distributes its products through a direct sales and
telesales force in the North America, wholly-owned subsidiaries in
Australia (61-2-212-2766), Germany (49-611-39707-0), Japan
(81-3-3251-2882), and the United Kingdom (44-793-486111) as well as
through distributors in 15 countries.

The US headquarters are located in Burlington, Mass., the company
maintains regional or district offices in Atlanta; Chicago; Los
Angeles; New York; Portland; San Mateo, Calif.; and Washington, DC.

You may obtain information about ObjectStore or Object Design by any
of the following methods:

Address:

    Object Design, Inc.
    25 Burlington Mall Road
    Burlington, MA 01803

Telephone:

    Call toll-free 1-800-962-9620 in the USA or 617-674-5000 and
    ask for telemarketing.

Internet:

    Send email requests to [e-mail].

    You can also download public information from our ftp server,
    ftp.odi.com (198.3.16.17).  Login as "anonymous", and use your
    mail address (username@site) as your password.  Major files of
    interest include:

    /pub/docs/techsum-net.ps    Technical Summary (postscript)
    /pub/docs/techsum.net        Technical Summary (FrameMaker)
    /pub/oo7/results.ps        OO7 Benchmark Results (postscript)

CompuServe:

    GO ODIFORUM, section 1.

International distributors contact information follows:

GERMANY

Patzschke + Rasp
Software und Systeme
Bierstadter StraBe 7
D-65189 Wiesbaden Germany
011-49-611-17-310
011-49-611-17-3131 FAX

SPAIN, PORTUGAL

DyM
Diseno y Metodologia, SA
Francisco Gervas, 17, 5.0 G
Madrid, Spain 28020011-34-1-571-3123 or 571-3880
011-34-1-571-3942 FAX


SWEDEN, NORWAY, DENMARK, FINLAND

ENEA Data
Box 4150
S-203 12 Malmo
Sweden
011-46-40-70930
011-46-40-230240 FAX

SWITZERLAND

UNISYS (Schweiz) AG
Zucherstrasse 59-61
A-8800 Thalwill
Switzerland
011-411-723-3366
011-411-720-3737 FAX

ITALY

AIS S.p.a.
Via Rombon, 11-20134
Milano, Italy
011-39-226-40197
011-39-2 2641-0744 FAX

ISRAEL

TACTLINE, Ltd.
Beit-Oved 76800
Israel
011-972-840-4898
011-972-840-6927 FAX

JAPAN

Mitsui Engineering & Shipbuilding Co., Ltd.(MES)
6-4 ,Tsukiji 5-chome
Chuo-ku,Tokyo, 104
011-81-3-3544-3355
011-81-3-3544-3036FAX

Stan Systems Corporation
Sumitomo Higashi Shinbashi Bldg.
1-1-11 Hamamatsucho
Minato-Ku, Tokyo 105 Japan
011-81-3-5472-5515
011-81-3-5472-5544 FAX


System Network Corporation:
Tohto Bldg. 6F
5-1-4 Toranomon, Minato-ku,
Tokyo  105 Japan
Phone#:   [phone]
Fax#:       [phone]

Toyo Information Systems Co.,Ltd.
Nihonbashi Toyo Bldg. 4F
2-7-24 Nihonbashi
Chuo-Ku, Tokyo 103 Japan
011-81-3-3271-7681
011-81-3-3271-7685 FAX

TAIWAN, R.O.C.

Exartech International Corp
10F, 82, Chung-Cheng S. RD.
Sanchung, Taipei, Taiwan, ROC
011-886-2-977-6828
011-886-2-977-6829 FAX

SOUTH AFRICA

Realtime Computer Services (Pty) Ltd.
4th Floor, 35 Wale Street
Cape Town 8001
South Africa
011 27 21 24 4350
011 27 21 221507 FAX


> Ontos [formerly VBase] (Ontologic)

Entry on schema evolution only:

*Ontos provides schema evolution. It allows any class to be modified.
*The major drawback is that data does not migrate ie., instances are
*not modified to adopt to the new class definition. So schema changes
*can be done only on classes that do not contain instances and do not
*have sub classes that contain instances.
*[[e-mail]]

*As a system for experiments, we are currently using ONTOS from
*Ontologic Inc.  Unfortunately, there is no transparent concept of
*schema evolution for populated database. Thus, we still investigate
*how it works.

ONTOS has a version of ONTOS for OS/2.  Approximately $11K. Others I don't know


> Odapter/OpenODB (Hewlett-Packard)

Odapter is HP's new object/relational adapter which
enables object-oriented developers to share a common
object model stored in the ORACLE7 relational database
management system (RDBMS).  Odapter is also available with
HP's ALLBASE/SQL RDBMS.  The combination of Odapter
and ALLBASE/SQL is called OpenODB.

Odapter
Technical Data
Object/Relational Adapter

A Productivity Tool for Scalable Object-Oriented
Applications

Odapter is a tool for developers writing scalable
object-oriented applications requiring the
integration of new objects and legacy information.
Odapter is valuable because it:
* accelerates application development
* reduces the cost of keeping applications current
* enables applications to scale

Odapter delivers the productivity of object
technology while adhering to your data management
standards.

Consider Odapter if you need to be able to do one
or more of the following:
* develop object-oriented applications and
store objects in a relational database
* easily access legacy data and existing
applications from your new system
* support a large number of end-users who will
be simultaneously accessing information
* store large amounts of  complex information

The following are examples of applications well-
suited for Odapter:
* a customer billing application written in
Smalltalk combining data stored in DB2 with new
objects. (Telecommunications)
* a network management application written in C
using Odapter as the object manager, able to scale
to millions of objects (Manufacturing)
* a complex Oil and Gas industry standard model
automatically generated from an Express analysis
and design tool.
(Oil & Gas)
* a medical application using Odapter to
combine heterogeneous components of patient
records. (Healthcare)

Odapter provides authorized access to sharable
objects, including existing data and business
processes. By bringing object-oriented capabilities
to heterogeneous systems environments, Odapter
delivers increased functionality while leveraging
the stability of existing RDBMSs and legacy
information.

Odapter Object Model

The Odapter object model is based on three key
concepts - objects, types and functions.
* Objects are a combination of data and
behavior (functions). Figure 2 is an example of an
object.
* Types are dynamic templates allowing you to
group together similar components or objects.
* Functions define the attributes,
relationships and behavior of objects. Odapter
supports four types of user-defined functions:

Stored functions define attributes and
relationships that are stored in the database. In
Figure 2, flightno is a stored function. The
functions aircraft and crew are also stored
functions with user-defined results.

SQL-based functions allow you to access existing
relational tables with Odapter's object-oriented
model. In Figure 2, citypair is an SQL-based
function accessing values from an existing
relational table.

OSQL-based functions define attributes and
relationships that are derived or calculated with
OSQL statements. In Figure 2, delay and depart are
OSQL-based functions. Delay calculates changes in
arrival and departure times based upon events that
disrupt the schedule; depart handles the update of
functions related to departure and transitions the
flight from OnGround to InAir.

External functions are a reference to code or data
stored outside of Odapter. In Figure 2, cancel is
an external function that executes code outside of
Odapter to free up resources no longer assigned to
the flight.

Odapter Language

The Odapter language can be combined with functions
implemented in C++, Smalltalk or C. You create and
manipulate objects, types and functions using
Odapter's object-oriented structured query language
(OSQL). OSQL is a functional language that is a
semantic superset of SQL, the structured query
language for relational databases. OSQL is a
computationally complete language with statements
allowing you to define and manipulate information
in your Odapter enhanced relational database,
specify authorization for individuals or groups,
define transactions, embed program logic within
functions, and administer the database.

OSQL includes programming flow statements, such as
IF/THEN/ELSE, FOR and WHILE. This procedural
language allows Odapter functions to model complex
behavior, simplifying your application code. By
decoupling behavior from the applications, multiple
applications can share information with benefits
such as consistency, security and integrity. See
Table 5 for a list of all OSQL statements.

Odapter Object Storage

Odapter objects are stored in the developer's
choice of relational databases. Odapter interfaces
to the underlying RDBMS through an SQL command
interface. Currently, developers can choose to
store their objects in ORACLE7 or HP ALLBASE/SQL.

The choice of RDBMS is made when a particular
database is created. The users are only limited by
the number of Odapter concurrent user licenses
purchased. This flexibility allows database
administrators to continue using their existing
administration procedures and keeps the group from
having to choose yet another database management
system.

During the initial development of an application,
developers can make rapid progress without
knowledge of the underlying relational database.
Optimization of the objects and how they are stored
in the underlying relational database is best
done during the deployment phase.

Odapter Development Environments

Odapter developers have a choice of development
environments. Whether Smalltalk, C++ or more
traditional C and C-linkable languages are used,
Odapter enables object storage in a scalable and
robust relational database. In fact, objects can be
shared between different applications, allowing
different projects to employ the best tools for the
job!

Odapter and Smalltalk

Odapter provides Smalltalk developers with
transparent access to information stored in the
underlying relational database.

Odapter's Smalltalk Class Builder utility
automatically generates ParcPlace Smalltalk
compatible classes and methods based upon an
Odapter object model. The developer can select
specific Odapter types and functions, resulting in
a corresponding set of Smalltalk classes and
methods. Once the Smalltalk schema is generated,
the Smalltalk developer can transparently access
the underlying relational database, as shown in
Figure 3.

printFlight
   |allFlightObjects|
   allFlightObject:=Flight allObjects.
   AllFlightObjects do: [:aFlight|
      Transcript show :aFlight flightno value; cr].
Figure 3


Figure 3 shows how to access the flight objects
shown in Figure 2 through Smalltalk. This example
retrieves all flight object identifiers and prints
the flight# for each one of the flight objects.

All Smalltalk classes and methods which result in
the access of Odapter structures are italicized.
Flight is a Smalltalk class that corresponds to the
Odapter type Flight. The Smalltalk methods
allObjects and flightno map to Odapter calls that
access data from the relational database storage
manager.

Odapter and C++

For C++ developers, once the corresponding C++
model is created, Odapter provides the abilility to
manage C++ objects stored in the underlying
relational database, as shown in Figure 4.

void printFlight()
{
   int i;
   ODBType Flight ("Flight");
   ODBBag allFlights=Flight.allObjects();
   ODBFunc flightno("flighno");

   for(i=0;i<allFlights.size();i++){
      cout<<flightno(allFlights[i]);
   }
}
Figure 4

Figure 4 shows a C++ version of the Smalltalk
example in Figure 3. That is, Figure 4 shows how to
access all the flight objects shown in Figure 2 and
prints the flight number associated with each
flight object.

The Odapter C++ library includes a set of classes
(e.g. ODBType, ODBClass, ODBFunc, ODBBag) and
corresponding member functions (e.g. allObjects).
User-defined classes (Flight) and member functions
(flightno) are also shown. In Figure 4, all Odapter
calls are in italics.

Odapter and C-linkable Languages

For traditional developers using C, or any
languages linkable with C, the object-oriented
features are provided by Odapter. Odapter objects
are manipulated by embedding OSQL statements in the
C program, similar to the db.execosql call shown in
Figure 4. In addition, the C interface requires the
conversion of data types from Odapter to C.

By embedding Odapter calls in a C program, the C
language becomes object-oriented.

Features and Benefits

Accelerates Application Development

Odapter accelerates application development by
integrating with familiar development environments
and by providing a robust object-oriented model.

Odapter's choice of development environments
includes those which support the Smalltalk, C++ and
C languages.

Odapter's robust object model enables the
integration of legacy data and business processes
in the context of one sharable business object
model, shielding the developer from the data
storage complexity.

The following Odapter features accelerate
application development:

Automatic mapping of objects to relational
databases
The application developer is shielded from the task
of converting complex object models to two
dimensional relational tables.

Smalltalk Class Builder
Once an OSQL schema is created, whether using
available analysis and design tools or manually,
Odapter's Smalltalk Class Builder can generate
corresponding Smalltalk classes and methods. The
developer can select the relevent part of the
Odapter schema to generate. As the Odapter object
model changes, developers can also incrementally
update the Smalltalk classes.

Object Identity
Each object manipulated by Odapter has a unique,
system-provided handle called an object identifier
(OID). OIDs eliminate the need for creating unique
keys to identify stored information. Additionally,
OIDs reduce duplication of information when several
attributes would be needed to uniquely identify
information in the database. OIDs are also a
powerful way to tune data access and performance.

Inheritance
Odapter objects can use functions defined on parent
types in the type hierarchy. For example, as shown
in Figure 5, a subtype of Employee called Pilot
could inherit functions from Employee like hire and
name, while defining unique functions like
hoursflown and status.


Multiple Inheritance
Functions defined on a type can be inherited by one
or more subtypes. In Figure 5, functions accessible
by the type ManagingPilot are inherited from its
parents, namely all functions defined on Employee,
Pilot and Manager. By inheriting rather than
redefining functions, you can easily add
functionality to your application.

OSQL
If you already know SQL, you can quickly be
productive using Odapter's OSQL. Both query
languages are set-based, that is they retrieve sets
of information based upon queries. Thus, OSQL does
not require users to navigate through the database
chasing pointers or object references.

Encapsulation
Odapter protects end-user applications from changes
to the internal definition of objects. Since
Odapter only allows access to data through
functions with well defined arguments and results,
your applications are protected from changes to the
function body and you have control over how
information is used.

Aggregate Types
Aggregates are used to represent collections, such
as crew members (maybe several pilots, flight
attendants and a mechanic) for a particular flight,
or the employees reporting to a particular manager.
Aggregates are not required to have a predetermined
size. Odapter manages the memory associated with
aggregates, relieving your application of this
work.

User-defined Data Types
You can construct user-defined data types in
Odapter, such as a type called Flight, Employee or
Aircraft, as shown in Figure 6. Functions defined
on these types can manipulate data stored within
the current object, within other related objects or
outside of Odapter. User-defined types maximize
flexibility and lead to more manageable, clearer
code.

Complex Objects
With Odapter you can construct complex objects from
simpler objects. For example, Figure 6 shows the
relationships between the types Flight, Aircraft
and Employee.  Complex objects relieve applications
from managing such relationships.


Reduces the Cost of Keeping Applications Current

Odapter supports a server-centric business model
which means the business logic and associated data
is sharable by multiple applications. By separating
out business objects (data and processes), from the
application development environment, your company's
business can be modified without impacting the
applications. These changes can be immediately
leveraged by the calling applications without
recompilation

The following features make applications easier to
keep current:

External Functions
Using external functions, you can access
distributed data and code stored outside of the
relational database used by Odapter for storage,
regardless of location or data format. Examples of
external data sources include IMS, DB2 as well as
custom databases and flat files. Odapter acts as an
integrator so your application can manipulate
information as recognizable business objects. This
not only allows transparent migration of data over
time, it accelerates developer productivity by
hiding the complexity of a diverse data storage
environment.

Overloaded Functions
Multiple functions can have the same name with
different implementations. An application calls a
function (e.g. salary) and Odapter determines at
run-time which code (salary for Manager or salary
for Pilot) to execute, based upon the type of the
object against which the function is invoked. The
application is simplified since the conditional
logic for determining which function to execute is
now in Odapter.

Dynamic Schema Modification
Odapter object models can be modified while the
database is running. Developers can add new
functions and types, as well as change the
implementation of functions. This capability is
particularly valuable to applications with high
availability requirements.

Dynamic Typing
You can change the type of an object without
destroying and recreating the object. An object can
also belong to more than one type. As shown in
Figure 7, once a Flight leaves the ground, it would
change state from being an OnGround to an InAir
Flight. OnGround functions such as maintenancecrew
and availableseats would no longer be needed. An
InAir object would need certain functions like
bestroute and delay to calculate the most time
efficient route and to calculate a projected delay
based current weather conditions. Dynamic Typing
allows you to represent an object in Odapter which
transforms itself over time and, therefore, changes
capabilities and attributes.

Late Binding
Odapter supports functions that are resolved at
runtime. Late binding allows you more flexibility
in application development and gives you the full
power of overloaded functions as described earlier.
On the other hand, Odapter will precompile or do
early binding to improve performance. However, when
types and functions changes at runtime, impacting a
particular function, late binding occurs and the
application automatically takes advantage of the
new implementation of the function when it is
called.

Referential Integrity
Since Odapter manages the relationships between
objects, it can manage referential integrity on
your behalf. That is, if an object referenced by
other objects is deleted, the system removes all
dependencies.  Your application code is simplified
since Odapter is able to keep the logical business
model intact automatically.

Multimedia
Odapter allows you to manage large, unformatted
data in binary format and treat that data as an
attribute of an object. For example, you may want
to create a function called diagram to show the
sections and seating for an Aircraft object.
Multimedia information can include graphics, images
and voice. You can also define functions in Odapter
to manipulate this multimedia information. For
example, you can create a function called showexits
that adds information to the diagram. Thus, various
applications can share these complex functions.

Import Facility
The Odapter Import facility allows developers to
update existing Odapter functions with data from
external files such as spreadsheets or other
databases. This is an object-oriented version of
the relational "bulk load" functionality.

Enables Applications to Scale

Odapter makes applications more scalable by storing
objects in a choice of RDBMSs, like ORACLE7. As a
result, applications can access large volumes of
data, be used by a large numbers of users, and
perform on-line backup. In addition, Odapter
protects against unauthorized access from users in
a distributed environment.

Odapter, with the help of the underlying relational
storage manager, ensures the integrity and security
of your data while maximizing the availability of
that data for end users.

The following features enable applications to
scale:

Indexing
Indexes are automatically generated when you create
types and functions in Odapter. You can also define
your own indexes using B-tree and hashing
algorithms. Indexes make end user access to
information faster.

Clustering
Related functions and objects which have the same
value for a function can be stored close to each
other. This ability to influence how objects are
stored allows you to tune the performance of the
database based on how the information will be
accessed by applications.

Transaction Management
Odapter ensures the logical and physical integrity
of your database by giving you complete control
over the unit of work to be performed within a
single transaction. With this control, you can save
or rollback a transaction (throw away temporary
work) at your discretion. Savepoints are also
supported so that you can rollback parts of a
transaction.

Multi-user Concurrency Control
Odapter is designed to support hundreds of users
accessing the same information while guaranteeing
the integrity of that information.

Authorization
You can control access to an Odapter enhanced
database at the database and function levels based
on individuals or groups of users. For example,
authorization statements can provide read access to
a large group of users while limiting write or
delete access.

High Availability
Because Odapter actually stores objects in an
RDBMS, Odapter can leverage RDBMS features to
maximize the availability of your information by
providing:
* on-line backup of the database, to backup the
database while it is being accessed
* dual logging, to ensure the integrity of your
log file
* switch log, to automatically switch to a
second log file if the original log file becomes
full
* dynamic file expansion, to expand the size of
your database as it becomes full

Odapter will also take advantage of other available
features of the underlying relational database
management system such as replication or "warm
standby".

Recovery
Odapter uses the robust logging and recovery
facilities of the RDBMS. In case of a failure, you
can rollback work or perform rollforward recovery
to a particular time, using the log file to
recreate saved work.

Odapter  Software Components

Odapter uses a client/server architecture, enabling
you to efficiently utilize your computing power.
Clients use the object application call interface
(OACI) to communicate with the server over the
network. The clients and server components can also
reside on the same machine.